home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / controls / Button.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  50.1 KB  |  1,530 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.FocusEvent;
  6.    import flash.events.KeyboardEvent;
  7.    import flash.events.MouseEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.text.TextLineMetrics;
  10.    import flash.ui.Keyboard;
  11.    import flash.utils.Timer;
  12.    import mx.controls.dataGridClasses.DataGridListData;
  13.    import mx.controls.listClasses.BaseListData;
  14.    import mx.controls.listClasses.IDropInListItemRenderer;
  15.    import mx.controls.listClasses.IListItemRenderer;
  16.    import mx.core.EdgeMetrics;
  17.    import mx.core.FlexVersion;
  18.    import mx.core.IBorder;
  19.    import mx.core.IButton;
  20.    import mx.core.IDataRenderer;
  21.    import mx.core.IFlexAsset;
  22.    import mx.core.IFlexDisplayObject;
  23.    import mx.core.IFlexModuleFactory;
  24.    import mx.core.IFontContextComponent;
  25.    import mx.core.IInvalidating;
  26.    import mx.core.IProgrammaticSkin;
  27.    import mx.core.IRectangularBorder;
  28.    import mx.core.IStateClient;
  29.    import mx.core.IUIComponent;
  30.    import mx.core.IUITextField;
  31.    import mx.core.UIComponent;
  32.    import mx.core.UITextField;
  33.    import mx.core.mx_internal;
  34.    import mx.events.FlexEvent;
  35.    import mx.events.MoveEvent;
  36.    import mx.events.SandboxMouseEvent;
  37.    import mx.managers.IFocusManagerComponent;
  38.    import mx.styles.ISimpleStyleClient;
  39.    
  40.    use namespace mx_internal;
  41.    
  42.    public class Button extends UIComponent implements IDataRenderer, IDropInListItemRenderer, IFocusManagerComponent, IListItemRenderer, IFontContextComponent, IButton
  43.    {
  44.       mx_internal static var createAccessibilityImplementation:Function;
  45.       
  46.       mx_internal static const VERSION:String = "3.2.0.3958";
  47.       
  48.       mx_internal static var TEXT_WIDTH_PADDING:Number = UITextField.mx_internal::TEXT_WIDTH_PADDING + 1;
  49.       
  50.       mx_internal var _emphasized:Boolean = false;
  51.       
  52.       mx_internal var extraSpacing:Number = 20;
  53.       
  54.       private var icons:Array;
  55.       
  56.       public var selectedField:String = null;
  57.       
  58.       private var labelChanged:Boolean = false;
  59.       
  60.       private var skinMeasuredWidth:Number;
  61.       
  62.       mx_internal var checkedDefaultSkin:Boolean = false;
  63.       
  64.       private var autoRepeatTimer:Timer;
  65.       
  66.       mx_internal var disabledIconName:String = "disabledIcon";
  67.       
  68.       mx_internal var disabledSkinName:String = "disabledSkin";
  69.       
  70.       mx_internal var checkedDefaultIcon:Boolean = false;
  71.       
  72.       public var stickyHighlighting:Boolean = false;
  73.       
  74.       private var enabledChanged:Boolean = false;
  75.       
  76.       mx_internal var selectedUpIconName:String = "selectedUpIcon";
  77.       
  78.       mx_internal var selectedUpSkinName:String = "selectedUpSkin";
  79.       
  80.       mx_internal var upIconName:String = "upIcon";
  81.       
  82.       mx_internal var upSkinName:String = "upSkin";
  83.       
  84.       mx_internal var centerContent:Boolean = true;
  85.       
  86.       mx_internal var buttonOffset:Number = 0;
  87.       
  88.       private var skinMeasuredHeight:Number;
  89.       
  90.       private var oldUnscaledWidth:Number;
  91.       
  92.       mx_internal var downIconName:String = "downIcon";
  93.       
  94.       mx_internal var _labelPlacement:String = "right";
  95.       
  96.       mx_internal var downSkinName:String = "downSkin";
  97.       
  98.       mx_internal var _toggle:Boolean = false;
  99.       
  100.       private var _phase:String = "up";
  101.       
  102.       private var toolTipSet:Boolean = false;
  103.       
  104.       private var _data:Object;
  105.       
  106.       mx_internal var currentIcon:IFlexDisplayObject;
  107.       
  108.       mx_internal var currentSkin:IFlexDisplayObject;
  109.       
  110.       mx_internal var overIconName:String = "overIcon";
  111.       
  112.       mx_internal var selectedDownIconName:String = "selectedDownIcon";
  113.       
  114.       mx_internal var overSkinName:String = "overSkin";
  115.       
  116.       mx_internal var iconName:String = "icon";
  117.       
  118.       mx_internal var skinName:String = "skin";
  119.       
  120.       mx_internal var selectedDownSkinName:String = "selectedDownSkin";
  121.       
  122.       private var skins:Array;
  123.       
  124.       private var selectedSet:Boolean;
  125.       
  126.       private var _autoRepeat:Boolean = false;
  127.       
  128.       private var styleChangedFlag:Boolean = true;
  129.       
  130.       mx_internal var selectedOverIconName:String = "selectedOverIcon";
  131.       
  132.       private var _listData:BaseListData;
  133.       
  134.       mx_internal var selectedOverSkinName:String = "selectedOverSkin";
  135.       
  136.       protected var textField:IUITextField;
  137.       
  138.       private var labelSet:Boolean;
  139.       
  140.       mx_internal var defaultIconUsesStates:Boolean = false;
  141.       
  142.       mx_internal var defaultSkinUsesStates:Boolean = false;
  143.       
  144.       mx_internal var toggleChanged:Boolean = false;
  145.       
  146.       private var emphasizedChanged:Boolean = false;
  147.       
  148.       private var _label:String = "";
  149.       
  150.       mx_internal var _selected:Boolean = false;
  151.       
  152.       mx_internal var selectedDisabledIconName:String = "selectedDisabledIcon";
  153.       
  154.       mx_internal var selectedDisabledSkinName:String = "selectedDisabledSkin";
  155.       
  156.       public function Button()
  157.       {
  158.          skins = [];
  159.          icons = [];
  160.          super();
  161.          mouseChildren = false;
  162.          addEventListener(MouseEvent.ROLL_OVER,rollOverHandler);
  163.          addEventListener(MouseEvent.ROLL_OUT,rollOutHandler);
  164.          addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  165.          addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler);
  166.          addEventListener(MouseEvent.CLICK,clickHandler);
  167.       }
  168.       
  169.       private function previousVersion_measure() : void
  170.       {
  171.          var iconHeight:Number;
  172.          var iconWidth:Number;
  173.          var textWidth:Number;
  174.          var tempCurrentIcon:IFlexDisplayObject;
  175.          var h:Number;
  176.          var textHeight:Number;
  177.          var w:Number;
  178.          var bm:EdgeMetrics = null;
  179.          var lineMetrics:TextLineMetrics = null;
  180.          var paddingLeft:Number = NaN;
  181.          var paddingRight:Number = NaN;
  182.          var paddingTop:Number = NaN;
  183.          var paddingBottom:Number = NaN;
  184.          var horizontalGap:Number = NaN;
  185.          super.measure();
  186.          textWidth = 0;
  187.          textHeight = 0;
  188.          if(label)
  189.          {
  190.             lineMetrics = measureText(label);
  191.             textWidth = lineMetrics.width;
  192.             textHeight = lineMetrics.height;
  193.             paddingLeft = getStyle("paddingLeft");
  194.             paddingRight = getStyle("paddingRight");
  195.             paddingTop = getStyle("paddingTop");
  196.             paddingBottom = getStyle("paddingBottom");
  197.             textWidth += paddingLeft + paddingRight + getStyle("textIndent");
  198.             textHeight += paddingTop + paddingBottom;
  199.          }
  200.          try
  201.          {
  202.             bm = mx_internal::currentSkin["borderMetrics"];
  203.          }
  204.          catch(e:Error)
  205.          {
  206.             bm = new EdgeMetrics(3,3,3,3);
  207.          }
  208.          tempCurrentIcon = mx_internal::getCurrentIcon();
  209.          iconWidth = !!tempCurrentIcon ? Number(tempCurrentIcon.width) : 0;
  210.          iconHeight = !!tempCurrentIcon ? Number(tempCurrentIcon.height) : 0;
  211.          w = 0;
  212.          h = 0;
  213.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  214.          {
  215.             w = textWidth + iconWidth;
  216.             if(iconWidth != 0)
  217.             {
  218.                horizontalGap = getStyle("horizontalGap");
  219.                w += horizontalGap - 2;
  220.             }
  221.             h = Math.max(textHeight,iconHeight + 6);
  222.          }
  223.          else
  224.          {
  225.             w = Math.max(textWidth,iconWidth);
  226.             h = textHeight + iconHeight;
  227.             if(iconHeight != 0)
  228.             {
  229.                h += getStyle("verticalGap");
  230.             }
  231.          }
  232.          if(bm)
  233.          {
  234.             w += bm.left + bm.right;
  235.             h += bm.top + bm.bottom;
  236.          }
  237.          if(Boolean(label) && label.length != 0)
  238.          {
  239.             w += mx_internal::extraSpacing;
  240.          }
  241.          else
  242.          {
  243.             w += 6;
  244.          }
  245.          if(Boolean(mx_internal::currentSkin) && (isNaN(skinMeasuredWidth) || isNaN(skinMeasuredHeight)))
  246.          {
  247.             skinMeasuredWidth = mx_internal::currentSkin.measuredWidth;
  248.             skinMeasuredHeight = mx_internal::currentSkin.measuredHeight;
  249.          }
  250.          if(!isNaN(skinMeasuredWidth))
  251.          {
  252.             w = Math.max(skinMeasuredWidth,w);
  253.          }
  254.          if(!isNaN(skinMeasuredHeight))
  255.          {
  256.             h = Math.max(skinMeasuredHeight,h);
  257.          }
  258.          measuredMinWidth = measuredWidth = w;
  259.          measuredMinHeight = measuredHeight = h;
  260.       }
  261.       
  262.       [Bindable("labelChanged")]
  263.       public function get label() : String
  264.       {
  265.          return _label;
  266.       }
  267.       
  268.       mx_internal function getCurrentIconName() : String
  269.       {
  270.          var _loc1_:String = null;
  271.          if(!enabled)
  272.          {
  273.             _loc1_ = selected ? mx_internal::selectedDisabledIconName : mx_internal::disabledIconName;
  274.          }
  275.          else if(mx_internal::phase == ButtonPhase.UP)
  276.          {
  277.             _loc1_ = selected ? mx_internal::selectedUpIconName : mx_internal::upIconName;
  278.          }
  279.          else if(mx_internal::phase == ButtonPhase.OVER)
  280.          {
  281.             _loc1_ = selected ? mx_internal::selectedOverIconName : mx_internal::overIconName;
  282.          }
  283.          else if(mx_internal::phase == ButtonPhase.DOWN)
  284.          {
  285.             _loc1_ = selected ? mx_internal::selectedDownIconName : mx_internal::downIconName;
  286.          }
  287.          return _loc1_;
  288.       }
  289.       
  290.       protected function mouseUpHandler(param1:MouseEvent) : void
  291.       {
  292.          if(!enabled)
  293.          {
  294.             return;
  295.          }
  296.          mx_internal::phase = ButtonPhase.OVER;
  297.          mx_internal::buttonReleased();
  298.          if(!toggle)
  299.          {
  300.             param1.updateAfterEvent();
  301.          }
  302.       }
  303.       
  304.       override protected function adjustFocusRect(param1:DisplayObject = null) : void
  305.       {
  306.          super.adjustFocusRect(!mx_internal::currentSkin ? DisplayObject(mx_internal::currentIcon) : this);
  307.       }
  308.       
  309.       mx_internal function set phase(param1:String) : void
  310.       {
  311.          _phase = param1;
  312.          invalidateSize();
  313.          invalidateDisplayList();
  314.       }
  315.       
  316.       mx_internal function viewIconForPhase(param1:String) : IFlexDisplayObject
  317.       {
  318.          var _loc3_:IFlexDisplayObject = null;
  319.          var _loc4_:Boolean = false;
  320.          var _loc5_:String = null;
  321.          var _loc2_:Class = Class(getStyle(param1));
  322.          if(!_loc2_)
  323.          {
  324.             _loc2_ = Class(getStyle(mx_internal::iconName));
  325.             if(mx_internal::defaultIconUsesStates)
  326.             {
  327.                param1 = mx_internal::iconName;
  328.             }
  329.             if(!mx_internal::checkedDefaultIcon && Boolean(_loc2_))
  330.             {
  331.                _loc3_ = IFlexDisplayObject(new _loc2_());
  332.                if(!(_loc3_ is IProgrammaticSkin) && _loc3_ is IStateClient)
  333.                {
  334.                   mx_internal::defaultIconUsesStates = true;
  335.                   param1 = mx_internal::iconName;
  336.                }
  337.                if(_loc3_)
  338.                {
  339.                   mx_internal::checkedDefaultIcon = true;
  340.                }
  341.             }
  342.          }
  343.          _loc3_ = IFlexDisplayObject(getChildByName(param1));
  344.          if(_loc3_ == null)
  345.          {
  346.             if(_loc2_ != null)
  347.             {
  348.                _loc3_ = IFlexDisplayObject(new _loc2_());
  349.                _loc3_.name = param1;
  350.                if(_loc3_ is ISimpleStyleClient)
  351.                {
  352.                   ISimpleStyleClient(_loc3_).styleName = this;
  353.                }
  354.                addChild(DisplayObject(_loc3_));
  355.                _loc4_ = false;
  356.                if(_loc3_ is IInvalidating)
  357.                {
  358.                   IInvalidating(_loc3_).validateNow();
  359.                   _loc4_ = true;
  360.                }
  361.                else if(_loc3_ is IProgrammaticSkin)
  362.                {
  363.                   IProgrammaticSkin(_loc3_).validateDisplayList();
  364.                   _loc4_ = true;
  365.                }
  366.                if(Boolean(_loc3_) && _loc3_ is IUIComponent)
  367.                {
  368.                   IUIComponent(_loc3_).enabled = enabled;
  369.                }
  370.                if(_loc4_)
  371.                {
  372.                   _loc3_.setActualSize(_loc3_.measuredWidth,_loc3_.measuredHeight);
  373.                }
  374.                icons.push(_loc3_);
  375.             }
  376.          }
  377.          if(mx_internal::currentIcon != null)
  378.          {
  379.             mx_internal::currentIcon.visible = false;
  380.          }
  381.          mx_internal::currentIcon = _loc3_;
  382.          if(mx_internal::defaultIconUsesStates && mx_internal::currentIcon is IStateClient)
  383.          {
  384.             _loc5_ = "";
  385.             if(!enabled)
  386.             {
  387.                _loc5_ = selected ? "selectedDisabled" : "disabled";
  388.             }
  389.             else if(mx_internal::phase == ButtonPhase.UP)
  390.             {
  391.                _loc5_ = selected ? "selectedUp" : "up";
  392.             }
  393.             else if(mx_internal::phase == ButtonPhase.OVER)
  394.             {
  395.                _loc5_ = selected ? "selectedOver" : "over";
  396.             }
  397.             else if(mx_internal::phase == ButtonPhase.DOWN)
  398.             {
  399.                _loc5_ = selected ? "selectedDown" : "down";
  400.             }
  401.             IStateClient(mx_internal::currentIcon).currentState = _loc5_;
  402.          }
  403.          if(mx_internal::currentIcon != null)
  404.          {
  405.             mx_internal::currentIcon.visible = true;
  406.          }
  407.          return _loc3_;
  408.       }
  409.       
  410.       mx_internal function viewSkinForPhase(param1:String, param2:String) : void
  411.       {
  412.          var _loc4_:IFlexDisplayObject = null;
  413.          var _loc5_:Number = NaN;
  414.          var _loc6_:ISimpleStyleClient = null;
  415.          var _loc3_:Class = Class(getStyle(param1));
  416.          if(!_loc3_)
  417.          {
  418.             _loc3_ = Class(getStyle(mx_internal::skinName));
  419.             if(mx_internal::defaultSkinUsesStates)
  420.             {
  421.                param1 = mx_internal::skinName;
  422.             }
  423.             if(!mx_internal::checkedDefaultSkin && Boolean(_loc3_))
  424.             {
  425.                _loc4_ = IFlexDisplayObject(new _loc3_());
  426.                if(!(_loc4_ is IProgrammaticSkin) && _loc4_ is IStateClient)
  427.                {
  428.                   mx_internal::defaultSkinUsesStates = true;
  429.                   param1 = mx_internal::skinName;
  430.                }
  431.                if(_loc4_)
  432.                {
  433.                   mx_internal::checkedDefaultSkin = true;
  434.                }
  435.             }
  436.          }
  437.          _loc4_ = IFlexDisplayObject(getChildByName(param1));
  438.          if(!_loc4_)
  439.          {
  440.             if(_loc3_)
  441.             {
  442.                _loc4_ = IFlexDisplayObject(new _loc3_());
  443.                _loc4_.name = param1;
  444.                _loc6_ = _loc4_ as ISimpleStyleClient;
  445.                if(_loc6_)
  446.                {
  447.                   _loc6_.styleName = this;
  448.                }
  449.                addChild(DisplayObject(_loc4_));
  450.                _loc4_.setActualSize(unscaledWidth,unscaledHeight);
  451.                if(_loc4_ is IInvalidating && initialized)
  452.                {
  453.                   IInvalidating(_loc4_).validateNow();
  454.                }
  455.                else if(_loc4_ is IProgrammaticSkin && initialized)
  456.                {
  457.                   IProgrammaticSkin(_loc4_).validateDisplayList();
  458.                }
  459.                skins.push(_loc4_);
  460.             }
  461.          }
  462.          if(mx_internal::currentSkin)
  463.          {
  464.             mx_internal::currentSkin.visible = false;
  465.          }
  466.          mx_internal::currentSkin = _loc4_;
  467.          if(mx_internal::defaultSkinUsesStates && mx_internal::currentSkin is IStateClient)
  468.          {
  469.             IStateClient(mx_internal::currentSkin).currentState = param2;
  470.          }
  471.          if(mx_internal::currentSkin)
  472.          {
  473.             mx_internal::currentSkin.visible = true;
  474.          }
  475.          if(enabled)
  476.          {
  477.             if(mx_internal::phase == ButtonPhase.OVER)
  478.             {
  479.                _loc5_ = textField.getStyle("textRollOverColor");
  480.             }
  481.             else if(mx_internal::phase == ButtonPhase.DOWN)
  482.             {
  483.                _loc5_ = textField.getStyle("textSelectedColor");
  484.             }
  485.             else
  486.             {
  487.                _loc5_ = textField.getStyle("color");
  488.             }
  489.             textField.setColor(_loc5_);
  490.          }
  491.       }
  492.       
  493.       mx_internal function getTextField() : IUITextField
  494.       {
  495.          return textField;
  496.       }
  497.       
  498.       protected function rollOverHandler(param1:MouseEvent) : void
  499.       {
  500.          if(mx_internal::phase == ButtonPhase.UP)
  501.          {
  502.             if(param1.buttonDown)
  503.             {
  504.                return;
  505.             }
  506.             mx_internal::phase = ButtonPhase.OVER;
  507.             param1.updateAfterEvent();
  508.          }
  509.          else if(mx_internal::phase == ButtonPhase.OVER)
  510.          {
  511.             mx_internal::phase = ButtonPhase.DOWN;
  512.             param1.updateAfterEvent();
  513.             if(autoRepeatTimer)
  514.             {
  515.                autoRepeatTimer.start();
  516.             }
  517.          }
  518.       }
  519.       
  520.       override protected function createChildren() : void
  521.       {
  522.          super.createChildren();
  523.          if(!textField)
  524.          {
  525.             textField = IUITextField(createInFontContext(UITextField));
  526.             textField.styleName = this;
  527.             addChild(DisplayObject(textField));
  528.          }
  529.       }
  530.       
  531.       mx_internal function setSelected(param1:Boolean, param2:Boolean = false) : void
  532.       {
  533.          if(mx_internal::_selected != param1)
  534.          {
  535.             mx_internal::_selected = param1;
  536.             invalidateDisplayList();
  537.             if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  538.             {
  539.                if(toggle)
  540.                {
  541.                   dispatchEvent(new Event(Event.CHANGE));
  542.                }
  543.             }
  544.             else if(toggle && !param2)
  545.             {
  546.                dispatchEvent(new Event(Event.CHANGE));
  547.             }
  548.             dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  549.          }
  550.       }
  551.       
  552.       private function autoRepeatTimer_timerDelayHandler(param1:Event) : void
  553.       {
  554.          if(!enabled)
  555.          {
  556.             return;
  557.          }
  558.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  559.          if(autoRepeat)
  560.          {
  561.             autoRepeatTimer.reset();
  562.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  563.             autoRepeatTimer.delay = getStyle("repeatInterval");
  564.             autoRepeatTimer.addEventListener(TimerEvent.TIMER,autoRepeatTimer_timerHandler);
  565.             autoRepeatTimer.start();
  566.          }
  567.       }
  568.       
  569.       public function get autoRepeat() : Boolean
  570.       {
  571.          return _autoRepeat;
  572.       }
  573.       
  574.       public function set selected(param1:Boolean) : void
  575.       {
  576.          selectedSet = true;
  577.          mx_internal::setSelected(param1,true);
  578.       }
  579.       
  580.       override protected function focusOutHandler(param1:FocusEvent) : void
  581.       {
  582.          super.focusOutHandler(param1);
  583.          if(mx_internal::phase != ButtonPhase.UP)
  584.          {
  585.             mx_internal::phase = ButtonPhase.UP;
  586.          }
  587.       }
  588.       
  589.       [Bindable("labelPlacementChanged")]
  590.       public function get labelPlacement() : String
  591.       {
  592.          return mx_internal::_labelPlacement;
  593.       }
  594.       
  595.       public function set autoRepeat(param1:Boolean) : void
  596.       {
  597.          _autoRepeat = param1;
  598.          if(param1)
  599.          {
  600.             autoRepeatTimer = new Timer(1);
  601.          }
  602.          else
  603.          {
  604.             autoRepeatTimer = null;
  605.          }
  606.       }
  607.       
  608.       mx_internal function changeIcons() : void
  609.       {
  610.          var _loc1_:int = int(icons.length);
  611.          var _loc2_:int = 0;
  612.          while(_loc2_ < _loc1_)
  613.          {
  614.             removeChild(icons[_loc2_]);
  615.             _loc2_++;
  616.          }
  617.          icons = [];
  618.          mx_internal::checkedDefaultIcon = false;
  619.          mx_internal::defaultIconUsesStates = false;
  620.       }
  621.       
  622.       public function set data(param1:Object) : void
  623.       {
  624.          var _loc2_:* = undefined;
  625.          var _loc3_:* = undefined;
  626.          _data = param1;
  627.          if(_listData && _listData is DataGridListData && DataGridListData(_listData).dataField != null)
  628.          {
  629.             _loc2_ = _data[DataGridListData(_listData).dataField];
  630.             _loc3_ = "";
  631.          }
  632.          else if(_listData)
  633.          {
  634.             if(selectedField)
  635.             {
  636.                _loc2_ = _data[selectedField];
  637.             }
  638.             _loc3_ = _listData.label;
  639.          }
  640.          else
  641.          {
  642.             _loc2_ = _data;
  643.          }
  644.          if(_loc2_ !== undefined && !selectedSet)
  645.          {
  646.             selected = _loc2_ as Boolean;
  647.             selectedSet = false;
  648.          }
  649.          if(_loc3_ !== undefined && !labelSet)
  650.          {
  651.             label = _loc3_;
  652.             labelSet = false;
  653.          }
  654.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  655.       }
  656.       
  657.       mx_internal function getCurrentIcon() : IFlexDisplayObject
  658.       {
  659.          var _loc1_:String = mx_internal::getCurrentIconName();
  660.          if(!_loc1_)
  661.          {
  662.             return null;
  663.          }
  664.          return mx_internal::viewIconForPhase(_loc1_);
  665.       }
  666.       
  667.       public function get fontContext() : IFlexModuleFactory
  668.       {
  669.          return moduleFactory;
  670.       }
  671.       
  672.       public function get emphasized() : Boolean
  673.       {
  674.          return mx_internal::_emphasized;
  675.       }
  676.       
  677.       [Bindable("dataChange")]
  678.       public function get listData() : BaseListData
  679.       {
  680.          return _listData;
  681.       }
  682.       
  683.       mx_internal function layoutContents(param1:Number, param2:Number, param3:Boolean) : void
  684.       {
  685.          var _loc20_:TextLineMetrics = null;
  686.          var _loc28_:MoveEvent = null;
  687.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  688.          {
  689.             previousVersion_layoutContents(param1,param2,param3);
  690.             return;
  691.          }
  692.          var _loc4_:Number = 0;
  693.          var _loc5_:Number = 0;
  694.          var _loc6_:Number = 0;
  695.          var _loc7_:Number = 0;
  696.          var _loc8_:Number = 0;
  697.          var _loc9_:Number = 0;
  698.          var _loc10_:Number = 0;
  699.          var _loc11_:Number = 0;
  700.          var _loc12_:Number = 0;
  701.          var _loc13_:Number = 0;
  702.          var _loc14_:Number = getStyle("paddingLeft");
  703.          var _loc15_:Number = getStyle("paddingRight");
  704.          var _loc16_:Number = getStyle("paddingTop");
  705.          var _loc17_:Number = getStyle("paddingBottom");
  706.          var _loc18_:Number = 0;
  707.          var _loc19_:Number = 0;
  708.          if(label)
  709.          {
  710.             _loc20_ = measureText(label);
  711.             _loc18_ = _loc20_.width + mx_internal::TEXT_WIDTH_PADDING;
  712.             _loc19_ = _loc20_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  713.          }
  714.          else
  715.          {
  716.             _loc20_ = measureText("Wj");
  717.             _loc19_ = _loc20_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  718.          }
  719.          var _loc21_:Number = param3 ? mx_internal::buttonOffset : 0;
  720.          var _loc22_:String = getStyle("textAlign");
  721.          var _loc23_:Number = param1;
  722.          var _loc24_:Number = param2;
  723.          var _loc25_:EdgeMetrics = mx_internal::currentSkin && mx_internal::currentSkin is IBorder && !(mx_internal::currentSkin is IFlexAsset) ? IBorder(mx_internal::currentSkin).borderMetrics : null;
  724.          if(_loc25_)
  725.          {
  726.             _loc23_ -= _loc25_.left + _loc25_.right;
  727.             _loc24_ -= _loc25_.top + _loc25_.bottom;
  728.          }
  729.          if(mx_internal::currentIcon)
  730.          {
  731.             _loc8_ = Number(mx_internal::currentIcon.width);
  732.             _loc9_ = Number(mx_internal::currentIcon.height);
  733.          }
  734.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  735.          {
  736.             _loc12_ = getStyle("horizontalGap");
  737.             if(_loc8_ == 0 || _loc18_ == 0)
  738.             {
  739.                _loc12_ = 0;
  740.             }
  741.             if(_loc18_ > 0)
  742.             {
  743.                textField.width = _loc4_ = Math.max(Math.min(_loc23_ - _loc8_ - _loc12_ - _loc14_ - _loc15_,_loc18_),0);
  744.             }
  745.             else
  746.             {
  747.                textField.width = _loc4_ = 0;
  748.             }
  749.             textField.height = _loc5_ = Math.min(_loc24_,_loc19_);
  750.             if(_loc22_ == "left")
  751.             {
  752.                _loc6_ += _loc14_;
  753.             }
  754.             else if(_loc22_ == "right")
  755.             {
  756.                _loc6_ += _loc23_ - _loc4_ - _loc8_ - _loc12_ - _loc15_;
  757.             }
  758.             else
  759.             {
  760.                _loc6_ += (_loc23_ - _loc4_ - _loc8_ - _loc12_ - _loc14_ - _loc15_) / 2 + _loc14_;
  761.             }
  762.             if(labelPlacement == ButtonLabelPlacement.RIGHT)
  763.             {
  764.                _loc6_ += _loc8_ + _loc12_;
  765.                _loc10_ = _loc6_ - (_loc8_ + _loc12_);
  766.             }
  767.             else
  768.             {
  769.                _loc10_ = _loc6_ + _loc4_ + _loc12_;
  770.             }
  771.             _loc11_ = (_loc24_ - _loc9_ - _loc16_ - _loc17_) / 2 + _loc16_;
  772.             _loc7_ = (_loc24_ - _loc5_ - _loc16_ - _loc17_) / 2 + _loc16_;
  773.          }
  774.          else
  775.          {
  776.             _loc13_ = getStyle("verticalGap");
  777.             if(_loc9_ == 0 || label == "")
  778.             {
  779.                _loc13_ = 0;
  780.             }
  781.             if(_loc18_ > 0)
  782.             {
  783.                textField.width = _loc4_ = Math.max(_loc23_ - _loc14_ - _loc15_,0);
  784.                textField.height = _loc5_ = Math.min(_loc24_ - _loc9_ - _loc16_ - _loc17_ - _loc13_,_loc19_);
  785.             }
  786.             else
  787.             {
  788.                textField.width = _loc4_ = 0;
  789.                textField.height = _loc5_ = 0;
  790.             }
  791.             _loc6_ = _loc14_;
  792.             if(_loc22_ == "left")
  793.             {
  794.                _loc10_ += _loc14_;
  795.             }
  796.             else if(_loc22_ == "right")
  797.             {
  798.                _loc10_ += Math.max(_loc23_ - _loc8_ - _loc15_,_loc14_);
  799.             }
  800.             else
  801.             {
  802.                _loc10_ += (_loc23_ - _loc8_ - _loc14_ - _loc15_) / 2 + _loc14_;
  803.             }
  804.             if(labelPlacement == ButtonLabelPlacement.TOP)
  805.             {
  806.                _loc7_ += (_loc24_ - _loc5_ - _loc9_ - _loc16_ - _loc17_ - _loc13_) / 2 + _loc16_;
  807.                _loc11_ += _loc7_ + _loc5_ + _loc13_;
  808.             }
  809.             else
  810.             {
  811.                _loc11_ += (_loc24_ - _loc5_ - _loc9_ - _loc16_ - _loc17_ - _loc13_) / 2 + _loc16_;
  812.                _loc7_ += _loc11_ + _loc9_ + _loc13_;
  813.             }
  814.          }
  815.          var _loc26_:Number = _loc21_;
  816.          var _loc27_:Number = _loc21_;
  817.          if(_loc25_)
  818.          {
  819.             _loc26_ += _loc25_.left;
  820.             _loc27_ += _loc25_.top;
  821.          }
  822.          textField.x = Math.round(_loc6_ + _loc26_);
  823.          textField.y = Math.round(_loc7_ + _loc27_);
  824.          if(mx_internal::currentIcon)
  825.          {
  826.             _loc10_ += _loc26_;
  827.             _loc11_ += _loc27_;
  828.             _loc28_ = new MoveEvent(MoveEvent.MOVE);
  829.             _loc28_.oldX = mx_internal::currentIcon.x;
  830.             _loc28_.oldY = mx_internal::currentIcon.y;
  831.             mx_internal::currentIcon.x = Math.round(_loc10_);
  832.             mx_internal::currentIcon.y = Math.round(_loc11_);
  833.             mx_internal::currentIcon.dispatchEvent(_loc28_);
  834.          }
  835.          if(mx_internal::currentSkin)
  836.          {
  837.             setChildIndex(DisplayObject(mx_internal::currentSkin),numChildren - 1);
  838.          }
  839.          if(mx_internal::currentIcon)
  840.          {
  841.             setChildIndex(DisplayObject(mx_internal::currentIcon),numChildren - 1);
  842.          }
  843.          if(textField)
  844.          {
  845.             setChildIndex(DisplayObject(textField),numChildren - 1);
  846.          }
  847.       }
  848.       
  849.       protected function mouseDownHandler(param1:MouseEvent) : void
  850.       {
  851.          if(!enabled)
  852.          {
  853.             return;
  854.          }
  855.          systemManager.getSandboxRoot().addEventListener(MouseEvent.MOUSE_UP,systemManager_mouseUpHandler,true);
  856.          systemManager.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,stage_mouseLeaveHandler);
  857.          mx_internal::buttonPressed();
  858.          param1.updateAfterEvent();
  859.       }
  860.       
  861.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  862.       {
  863.          if(!enabled)
  864.          {
  865.             return;
  866.          }
  867.          if(param1.keyCode == Keyboard.SPACE)
  868.          {
  869.             mx_internal::buttonPressed();
  870.          }
  871.       }
  872.       
  873.       protected function rollOutHandler(param1:MouseEvent) : void
  874.       {
  875.          if(mx_internal::phase == ButtonPhase.OVER)
  876.          {
  877.             mx_internal::phase = ButtonPhase.UP;
  878.             param1.updateAfterEvent();
  879.          }
  880.          else if(mx_internal::phase == ButtonPhase.DOWN && !stickyHighlighting)
  881.          {
  882.             mx_internal::phase = ButtonPhase.OVER;
  883.             param1.updateAfterEvent();
  884.             if(autoRepeatTimer)
  885.             {
  886.                autoRepeatTimer.stop();
  887.             }
  888.          }
  889.       }
  890.       
  891.       mx_internal function get phase() : String
  892.       {
  893.          return _phase;
  894.       }
  895.       
  896.       override public function set enabled(param1:Boolean) : void
  897.       {
  898.          if(super.enabled == param1)
  899.          {
  900.             return;
  901.          }
  902.          super.enabled = param1;
  903.          enabledChanged = true;
  904.          invalidateProperties();
  905.          invalidateDisplayList();
  906.       }
  907.       
  908.       override protected function measure() : void
  909.       {
  910.          var _loc9_:TextLineMetrics = null;
  911.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  912.          {
  913.             previousVersion_measure();
  914.             return;
  915.          }
  916.          super.measure();
  917.          var _loc1_:Number = 0;
  918.          var _loc2_:Number = 0;
  919.          if(label)
  920.          {
  921.             _loc9_ = measureText(label);
  922.             _loc1_ = _loc9_.width + mx_internal::TEXT_WIDTH_PADDING;
  923.             _loc2_ = _loc9_.height + UITextField.mx_internal::TEXT_HEIGHT_PADDING;
  924.          }
  925.          var _loc3_:IFlexDisplayObject = mx_internal::getCurrentIcon();
  926.          var _loc4_:Number = !!_loc3_ ? Number(_loc3_.width) : 0;
  927.          var _loc5_:Number = !!_loc3_ ? Number(_loc3_.height) : 0;
  928.          var _loc6_:Number = 0;
  929.          var _loc7_:Number = 0;
  930.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  931.          {
  932.             _loc6_ = _loc1_ + _loc4_;
  933.             if(Boolean(_loc1_) && Boolean(_loc4_))
  934.             {
  935.                _loc6_ += getStyle("horizontalGap");
  936.             }
  937.             _loc7_ = Math.max(_loc2_,_loc5_);
  938.          }
  939.          else
  940.          {
  941.             _loc6_ = Math.max(_loc1_,_loc4_);
  942.             _loc7_ = _loc2_ + _loc5_;
  943.             if(Boolean(_loc2_) && Boolean(_loc5_))
  944.             {
  945.                _loc7_ += getStyle("verticalGap");
  946.             }
  947.          }
  948.          if(Boolean(_loc1_) || Boolean(_loc4_))
  949.          {
  950.             _loc6_ += getStyle("paddingLeft") + getStyle("paddingRight");
  951.             _loc7_ += getStyle("paddingTop") + getStyle("paddingBottom");
  952.          }
  953.          var _loc8_:EdgeMetrics = mx_internal::currentSkin && mx_internal::currentSkin is IBorder && !(mx_internal::currentSkin is IFlexAsset) ? IBorder(mx_internal::currentSkin).borderMetrics : null;
  954.          if(_loc8_)
  955.          {
  956.             _loc6_ += _loc8_.left + _loc8_.right;
  957.             _loc7_ += _loc8_.top + _loc8_.bottom;
  958.          }
  959.          if(Boolean(mx_internal::currentSkin) && (isNaN(skinMeasuredWidth) || isNaN(skinMeasuredHeight)))
  960.          {
  961.             skinMeasuredWidth = mx_internal::currentSkin.measuredWidth;
  962.             skinMeasuredHeight = mx_internal::currentSkin.measuredHeight;
  963.          }
  964.          if(!isNaN(skinMeasuredWidth))
  965.          {
  966.             _loc6_ = Math.max(skinMeasuredWidth,_loc6_);
  967.          }
  968.          if(!isNaN(skinMeasuredHeight))
  969.          {
  970.             _loc7_ = Math.max(skinMeasuredHeight,_loc7_);
  971.          }
  972.          measuredMinWidth = measuredWidth = _loc6_;
  973.          measuredMinHeight = measuredHeight = _loc7_;
  974.       }
  975.       
  976.       [Bindable("toggleChanged")]
  977.       public function get toggle() : Boolean
  978.       {
  979.          return mx_internal::_toggle;
  980.       }
  981.       
  982.       mx_internal function buttonReleased() : void
  983.       {
  984.          systemManager.getSandboxRoot().removeEventListener(MouseEvent.MOUSE_UP,systemManager_mouseUpHandler,true);
  985.          systemManager.getSandboxRoot().removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,stage_mouseLeaveHandler);
  986.          if(autoRepeatTimer)
  987.          {
  988.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  989.             autoRepeatTimer.removeEventListener(TimerEvent.TIMER,autoRepeatTimer_timerHandler);
  990.             autoRepeatTimer.reset();
  991.          }
  992.       }
  993.       
  994.       mx_internal function buttonPressed() : void
  995.       {
  996.          mx_internal::phase = ButtonPhase.DOWN;
  997.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  998.          if(autoRepeat)
  999.          {
  1000.             autoRepeatTimer.delay = getStyle("repeatDelay");
  1001.             autoRepeatTimer.addEventListener(TimerEvent.TIMER,autoRepeatTimer_timerDelayHandler);
  1002.             autoRepeatTimer.start();
  1003.          }
  1004.       }
  1005.       
  1006.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  1007.       {
  1008.          if(!enabled)
  1009.          {
  1010.             return;
  1011.          }
  1012.          if(param1.keyCode == Keyboard.SPACE)
  1013.          {
  1014.             mx_internal::buttonReleased();
  1015.             if(mx_internal::phase == ButtonPhase.DOWN)
  1016.             {
  1017.                dispatchEvent(new MouseEvent(MouseEvent.CLICK));
  1018.             }
  1019.             mx_internal::phase = ButtonPhase.UP;
  1020.          }
  1021.       }
  1022.       
  1023.       [Bindable("valueCommit")]
  1024.       [Bindable("click")]
  1025.       public function get selected() : Boolean
  1026.       {
  1027.          return mx_internal::_selected;
  1028.       }
  1029.       
  1030.       public function set labelPlacement(param1:String) : void
  1031.       {
  1032.          mx_internal::_labelPlacement = param1;
  1033.          invalidateSize();
  1034.          invalidateDisplayList();
  1035.          dispatchEvent(new Event("labelPlacementChanged"));
  1036.       }
  1037.       
  1038.       protected function clickHandler(param1:MouseEvent) : void
  1039.       {
  1040.          if(!enabled)
  1041.          {
  1042.             param1.stopImmediatePropagation();
  1043.             return;
  1044.          }
  1045.          if(toggle)
  1046.          {
  1047.             mx_internal::setSelected(!selected);
  1048.             param1.updateAfterEvent();
  1049.          }
  1050.       }
  1051.       
  1052.       override protected function initializeAccessibility() : void
  1053.       {
  1054.          if(Button.mx_internal::createAccessibilityImplementation != null)
  1055.          {
  1056.             Button.mx_internal::createAccessibilityImplementation(this);
  1057.          }
  1058.       }
  1059.       
  1060.       public function set toggle(param1:Boolean) : void
  1061.       {
  1062.          mx_internal::_toggle = param1;
  1063.          mx_internal::toggleChanged = true;
  1064.          invalidateProperties();
  1065.          invalidateDisplayList();
  1066.          dispatchEvent(new Event("toggleChanged"));
  1067.       }
  1068.       
  1069.       override public function get baselinePosition() : Number
  1070.       {
  1071.          var _loc1_:String = null;
  1072.          var _loc2_:TextLineMetrics = null;
  1073.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  1074.          {
  1075.             _loc1_ = label;
  1076.             if(!_loc1_)
  1077.             {
  1078.                _loc1_ = "Wj";
  1079.             }
  1080.             validateNow();
  1081.             if(!label && (labelPlacement == ButtonLabelPlacement.TOP || labelPlacement == ButtonLabelPlacement.BOTTOM))
  1082.             {
  1083.                _loc2_ = measureText(_loc1_);
  1084.                return (measuredHeight - _loc2_.height) / 2 + _loc2_.ascent;
  1085.             }
  1086.             return textField.y + measureText(_loc1_).ascent;
  1087.          }
  1088.          if(!mx_internal::validateBaselinePosition())
  1089.          {
  1090.             return NaN;
  1091.          }
  1092.          return textField.y + textField.baselinePosition;
  1093.       }
  1094.       
  1095.       [Bindable("dataChange")]
  1096.       public function get data() : Object
  1097.       {
  1098.          return _data;
  1099.       }
  1100.       
  1101.       public function set fontContext(param1:IFlexModuleFactory) : void
  1102.       {
  1103.          this.moduleFactory = param1;
  1104.       }
  1105.       
  1106.       mx_internal function viewSkin() : void
  1107.       {
  1108.          var _loc1_:String = null;
  1109.          var _loc2_:String = null;
  1110.          if(!enabled)
  1111.          {
  1112.             _loc1_ = selected ? mx_internal::selectedDisabledSkinName : mx_internal::disabledSkinName;
  1113.             _loc2_ = selected ? "selectedDisabled" : "disabled";
  1114.          }
  1115.          else if(mx_internal::phase == ButtonPhase.UP)
  1116.          {
  1117.             _loc1_ = selected ? mx_internal::selectedUpSkinName : mx_internal::upSkinName;
  1118.             _loc2_ = selected ? "selectedUp" : "up";
  1119.          }
  1120.          else if(mx_internal::phase == ButtonPhase.OVER)
  1121.          {
  1122.             _loc1_ = selected ? mx_internal::selectedOverSkinName : mx_internal::overSkinName;
  1123.             _loc2_ = selected ? "selectedOver" : "over";
  1124.          }
  1125.          else if(mx_internal::phase == ButtonPhase.DOWN)
  1126.          {
  1127.             _loc1_ = selected ? mx_internal::selectedDownSkinName : mx_internal::downSkinName;
  1128.             _loc2_ = selected ? "selectedDown" : "down";
  1129.          }
  1130.          mx_internal::viewSkinForPhase(_loc1_,_loc2_);
  1131.       }
  1132.       
  1133.       override public function styleChanged(param1:String) : void
  1134.       {
  1135.          styleChangedFlag = true;
  1136.          super.styleChanged(param1);
  1137.          if(!param1 || param1 == "styleName")
  1138.          {
  1139.             mx_internal::changeSkins();
  1140.             mx_internal::changeIcons();
  1141.             if(initialized)
  1142.             {
  1143.                mx_internal::viewSkin();
  1144.                mx_internal::viewIcon();
  1145.             }
  1146.          }
  1147.          else if(param1.toLowerCase().indexOf("skin") != -1)
  1148.          {
  1149.             mx_internal::changeSkins();
  1150.          }
  1151.          else if(param1.toLowerCase().indexOf("icon") != -1)
  1152.          {
  1153.             mx_internal::changeIcons();
  1154.             invalidateSize();
  1155.          }
  1156.       }
  1157.       
  1158.       public function set emphasized(param1:Boolean) : void
  1159.       {
  1160.          mx_internal::_emphasized = param1;
  1161.          emphasizedChanged = true;
  1162.          invalidateDisplayList();
  1163.       }
  1164.       
  1165.       mx_internal function viewIcon() : void
  1166.       {
  1167.          var _loc1_:String = mx_internal::getCurrentIconName();
  1168.          mx_internal::viewIconForPhase(_loc1_);
  1169.       }
  1170.       
  1171.       override public function set toolTip(param1:String) : void
  1172.       {
  1173.          super.toolTip = param1;
  1174.          if(param1)
  1175.          {
  1176.             toolTipSet = true;
  1177.          }
  1178.          else
  1179.          {
  1180.             toolTipSet = false;
  1181.             invalidateDisplayList();
  1182.          }
  1183.       }
  1184.       
  1185.       override protected function commitProperties() : void
  1186.       {
  1187.          super.commitProperties();
  1188.          if(hasFontContextChanged() && textField != null)
  1189.          {
  1190.             removeChild(DisplayObject(textField));
  1191.             textField = null;
  1192.          }
  1193.          if(!textField)
  1194.          {
  1195.             textField = IUITextField(createInFontContext(UITextField));
  1196.             textField.styleName = this;
  1197.             addChild(DisplayObject(textField));
  1198.             enabledChanged = true;
  1199.             mx_internal::toggleChanged = true;
  1200.          }
  1201.          if(!initialized)
  1202.          {
  1203.             mx_internal::viewSkin();
  1204.             mx_internal::viewIcon();
  1205.          }
  1206.          if(enabledChanged)
  1207.          {
  1208.             textField.enabled = enabled;
  1209.             if(Boolean(mx_internal::currentIcon) && mx_internal::currentIcon is IUIComponent)
  1210.             {
  1211.                IUIComponent(mx_internal::currentIcon).enabled = enabled;
  1212.             }
  1213.             enabledChanged = false;
  1214.          }
  1215.          if(mx_internal::toggleChanged)
  1216.          {
  1217.             if(!toggle)
  1218.             {
  1219.                selected = false;
  1220.             }
  1221.             mx_internal::toggleChanged = false;
  1222.          }
  1223.       }
  1224.       
  1225.       mx_internal function changeSkins() : void
  1226.       {
  1227.          var _loc1_:int = int(skins.length);
  1228.          var _loc2_:int = 0;
  1229.          while(_loc2_ < _loc1_)
  1230.          {
  1231.             removeChild(skins[_loc2_]);
  1232.             _loc2_++;
  1233.          }
  1234.          skins = [];
  1235.          skinMeasuredWidth = NaN;
  1236.          skinMeasuredHeight = NaN;
  1237.          mx_internal::checkedDefaultSkin = false;
  1238.          mx_internal::defaultSkinUsesStates = false;
  1239.          if(initialized && FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  1240.          {
  1241.             mx_internal::viewSkin();
  1242.             invalidateSize();
  1243.          }
  1244.       }
  1245.       
  1246.       private function autoRepeatTimer_timerHandler(param1:Event) : void
  1247.       {
  1248.          if(!enabled)
  1249.          {
  1250.             return;
  1251.          }
  1252.          dispatchEvent(new FlexEvent(FlexEvent.BUTTON_DOWN));
  1253.       }
  1254.       
  1255.       private function previousVersion_layoutContents(param1:Number, param2:Number, param3:Boolean) : void
  1256.       {
  1257.          var _loc20_:TextLineMetrics = null;
  1258.          var _loc28_:Number = NaN;
  1259.          var _loc29_:MoveEvent = null;
  1260.          var _loc4_:Number = 0;
  1261.          var _loc5_:Number = 0;
  1262.          var _loc6_:Number = 0;
  1263.          var _loc7_:Number = 0;
  1264.          var _loc8_:Number = 0;
  1265.          var _loc9_:Number = 0;
  1266.          var _loc10_:Number = 0;
  1267.          var _loc11_:Number = 0;
  1268.          var _loc12_:Number = 2;
  1269.          var _loc13_:Number = 2;
  1270.          var _loc14_:Number = getStyle("paddingLeft");
  1271.          var _loc15_:Number = getStyle("paddingRight");
  1272.          var _loc16_:Number = getStyle("paddingTop");
  1273.          var _loc17_:Number = getStyle("paddingBottom");
  1274.          var _loc18_:Number = 0;
  1275.          var _loc19_:Number = 0;
  1276.          if(label)
  1277.          {
  1278.             _loc20_ = measureText(label);
  1279.             if(_loc20_.width > 0)
  1280.             {
  1281.                _loc18_ = _loc14_ + _loc15_ + getStyle("textIndent") + _loc20_.width;
  1282.             }
  1283.             _loc19_ = _loc20_.height;
  1284.          }
  1285.          else
  1286.          {
  1287.             _loc20_ = measureText("Wj");
  1288.             _loc19_ = _loc20_.height;
  1289.          }
  1290.          var _loc21_:Number = param3 ? mx_internal::buttonOffset : 0;
  1291.          var _loc22_:String = getStyle("textAlign");
  1292.          var _loc23_:EdgeMetrics = Boolean(mx_internal::currentSkin) && mx_internal::currentSkin is IRectangularBorder ? IRectangularBorder(mx_internal::currentSkin).borderMetrics : null;
  1293.          var _loc24_:Number = param1;
  1294.          var _loc25_:Number = param2 - _loc16_ - _loc17_;
  1295.          if(_loc23_)
  1296.          {
  1297.             _loc24_ -= _loc23_.left + _loc23_.right;
  1298.             _loc25_ -= _loc23_.top + _loc23_.bottom;
  1299.          }
  1300.          if(mx_internal::currentIcon)
  1301.          {
  1302.             _loc8_ = Number(mx_internal::currentIcon.width);
  1303.             _loc9_ = Number(mx_internal::currentIcon.height);
  1304.          }
  1305.          if(labelPlacement == ButtonLabelPlacement.LEFT || labelPlacement == ButtonLabelPlacement.RIGHT)
  1306.          {
  1307.             _loc12_ = getStyle("horizontalGap");
  1308.             if(_loc8_ == 0 || _loc18_ == 0)
  1309.             {
  1310.                _loc12_ = 0;
  1311.             }
  1312.             if(_loc18_ > 0)
  1313.             {
  1314.                textField.width = _loc4_ = Math.max(_loc24_ - _loc8_ - _loc12_ - _loc14_ - _loc15_,0);
  1315.             }
  1316.             else
  1317.             {
  1318.                textField.width = _loc4_ = 0;
  1319.             }
  1320.             textField.height = _loc5_ = Math.min(_loc25_ + 2,_loc19_ + UITextField.mx_internal::TEXT_HEIGHT_PADDING);
  1321.             if(labelPlacement == ButtonLabelPlacement.RIGHT)
  1322.             {
  1323.                _loc6_ = _loc8_ + _loc12_;
  1324.                if(mx_internal::centerContent)
  1325.                {
  1326.                   if(_loc22_ == "left")
  1327.                   {
  1328.                      _loc6_ += _loc14_;
  1329.                   }
  1330.                   else if(_loc22_ == "right")
  1331.                   {
  1332.                      _loc6_ += _loc24_ - _loc4_ - _loc8_ - _loc12_ - _loc14_;
  1333.                   }
  1334.                   else
  1335.                   {
  1336.                      _loc28_ = (_loc24_ - _loc4_ - _loc8_ - _loc12_) / 2;
  1337.                      _loc6_ += Math.max(_loc28_,_loc14_);
  1338.                   }
  1339.                }
  1340.                _loc10_ = _loc6_ - (_loc8_ + _loc12_);
  1341.                if(!mx_internal::centerContent)
  1342.                {
  1343.                   _loc6_ += _loc14_;
  1344.                }
  1345.             }
  1346.             else
  1347.             {
  1348.                _loc6_ = _loc24_ - _loc4_ - _loc8_ - _loc12_ - _loc15_;
  1349.                if(mx_internal::centerContent)
  1350.                {
  1351.                   if(_loc22_ == "left")
  1352.                   {
  1353.                      _loc6_ = 2;
  1354.                   }
  1355.                   else if(_loc22_ == "right")
  1356.                   {
  1357.                      _loc6_--;
  1358.                   }
  1359.                   else if(_loc6_ > 0)
  1360.                   {
  1361.                      _loc6_ /= 2;
  1362.                   }
  1363.                }
  1364.                _loc10_ = _loc6_ + _loc4_ + _loc12_;
  1365.             }
  1366.             _loc11_ = _loc7_ = 0;
  1367.             if(mx_internal::centerContent)
  1368.             {
  1369.                _loc11_ = Math.round((_loc25_ - _loc9_) / 2) + _loc16_;
  1370.                _loc7_ = Math.round((_loc25_ - _loc5_) / 2) + _loc16_;
  1371.             }
  1372.             else
  1373.             {
  1374.                _loc7_ += Math.max(0,(_loc25_ - _loc5_) / 2) + _loc16_;
  1375.                _loc11_ += Math.max(0,(_loc25_ - _loc9_) / 2 - 1) + _loc16_;
  1376.             }
  1377.          }
  1378.          else
  1379.          {
  1380.             _loc13_ = getStyle("verticalGap");
  1381.             if(_loc9_ == 0 || _loc19_ == 0)
  1382.             {
  1383.                _loc13_ = 0;
  1384.             }
  1385.             if(_loc18_ > 0)
  1386.             {
  1387.                textField.width = _loc4_ = Math.min(_loc24_,_loc18_ + UITextField.mx_internal::TEXT_WIDTH_PADDING);
  1388.                textField.height = _loc5_ = Math.min(_loc25_ - _loc9_ + 1,_loc19_ + 5);
  1389.             }
  1390.             else
  1391.             {
  1392.                textField.width = _loc4_ = 0;
  1393.                textField.height = _loc5_ = 0;
  1394.             }
  1395.             _loc6_ = (_loc24_ - _loc4_) / 2;
  1396.             _loc10_ = (_loc24_ - _loc8_) / 2;
  1397.             if(labelPlacement == ButtonLabelPlacement.TOP)
  1398.             {
  1399.                _loc7_ = _loc25_ - _loc5_ - _loc9_ - _loc13_;
  1400.                if(mx_internal::centerContent && _loc7_ > 0)
  1401.                {
  1402.                   _loc7_ /= 2;
  1403.                }
  1404.                _loc7_ += _loc16_;
  1405.                _loc11_ = _loc7_ + _loc5_ + _loc13_ - 3;
  1406.             }
  1407.             else
  1408.             {
  1409.                _loc7_ = _loc9_ + _loc13_ + _loc16_;
  1410.                if(mx_internal::centerContent)
  1411.                {
  1412.                   _loc7_ += (_loc25_ - _loc5_ - _loc9_ - _loc13_) / 2 + 1;
  1413.                }
  1414.                _loc11_ = _loc7_ - _loc9_ - _loc13_ + 3;
  1415.             }
  1416.          }
  1417.          var _loc26_:Number = _loc21_;
  1418.          var _loc27_:Number = _loc21_;
  1419.          if(_loc23_)
  1420.          {
  1421.             _loc26_ += _loc23_.left;
  1422.             _loc27_ += _loc23_.top;
  1423.          }
  1424.          textField.x = _loc6_ + _loc26_;
  1425.          textField.y = _loc7_ + _loc27_;
  1426.          if(mx_internal::currentIcon)
  1427.          {
  1428.             _loc10_ += _loc26_;
  1429.             _loc11_ += _loc27_;
  1430.             _loc29_ = new MoveEvent(MoveEvent.MOVE);
  1431.             _loc29_.oldX = mx_internal::currentIcon.x;
  1432.             _loc29_.oldY = mx_internal::currentIcon.y;
  1433.             mx_internal::currentIcon.x = Math.round(_loc10_);
  1434.             mx_internal::currentIcon.y = Math.round(_loc11_);
  1435.             mx_internal::currentIcon.dispatchEvent(_loc29_);
  1436.          }
  1437.          if(mx_internal::currentSkin)
  1438.          {
  1439.             setChildIndex(DisplayObject(mx_internal::currentSkin),numChildren - 1);
  1440.          }
  1441.          if(mx_internal::currentIcon)
  1442.          {
  1443.             setChildIndex(DisplayObject(mx_internal::currentIcon),numChildren - 1);
  1444.          }
  1445.          if(textField)
  1446.          {
  1447.             setChildIndex(DisplayObject(textField),numChildren - 1);
  1448.          }
  1449.       }
  1450.       
  1451.       private function systemManager_mouseUpHandler(param1:MouseEvent) : void
  1452.       {
  1453.          if(contains(DisplayObject(param1.target)))
  1454.          {
  1455.             return;
  1456.          }
  1457.          mx_internal::phase = ButtonPhase.UP;
  1458.          mx_internal::buttonReleased();
  1459.          param1.updateAfterEvent();
  1460.       }
  1461.       
  1462.       public function set label(param1:String) : void
  1463.       {
  1464.          labelSet = true;
  1465.          if(_label != param1)
  1466.          {
  1467.             _label = param1;
  1468.             labelChanged = true;
  1469.             invalidateSize();
  1470.             invalidateDisplayList();
  1471.             dispatchEvent(new Event("labelChanged"));
  1472.          }
  1473.       }
  1474.       
  1475.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1476.       {
  1477.          var _loc5_:IFlexDisplayObject = null;
  1478.          var _loc6_:Boolean = false;
  1479.          super.updateDisplayList(param1,param2);
  1480.          if(emphasizedChanged)
  1481.          {
  1482.             mx_internal::changeSkins();
  1483.             emphasizedChanged = false;
  1484.          }
  1485.          var _loc3_:int = int(skins.length);
  1486.          var _loc4_:int = 0;
  1487.          while(_loc4_ < _loc3_)
  1488.          {
  1489.             _loc5_ = IFlexDisplayObject(skins[_loc4_]);
  1490.             _loc5_.setActualSize(param1,param2);
  1491.             _loc4_++;
  1492.          }
  1493.          mx_internal::viewSkin();
  1494.          mx_internal::viewIcon();
  1495.          mx_internal::layoutContents(param1,param2,mx_internal::phase == ButtonPhase.DOWN);
  1496.          if(oldUnscaledWidth > param1 || textField.text != label || labelChanged || styleChangedFlag)
  1497.          {
  1498.             textField.text = label;
  1499.             _loc6_ = textField.truncateToFit();
  1500.             if(!toolTipSet)
  1501.             {
  1502.                if(_loc6_)
  1503.                {
  1504.                   super.toolTip = label;
  1505.                }
  1506.                else
  1507.                {
  1508.                   super.toolTip = null;
  1509.                }
  1510.             }
  1511.             styleChangedFlag = false;
  1512.             labelChanged = false;
  1513.          }
  1514.          oldUnscaledWidth = param1;
  1515.       }
  1516.       
  1517.       private function stage_mouseLeaveHandler(param1:Event) : void
  1518.       {
  1519.          mx_internal::phase = ButtonPhase.UP;
  1520.          mx_internal::buttonReleased();
  1521.       }
  1522.       
  1523.       public function set listData(param1:BaseListData) : void
  1524.       {
  1525.          _listData = param1;
  1526.       }
  1527.    }
  1528. }
  1529.  
  1530.